package DateStructure.Class3;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Demo1 {

    //杨辉三角形
    public static void main(String[] args) {
        List<List<Integer>> list=new ArrayList<>();
        List<Integer> list0=new ArrayList<>();
        list0.add(1);
        list.add(list0);

        for(int i=1;i<4;i++){
            List<Integer> curList=new ArrayList<>();
            curList.add(1);
            List<Integer> preList=list.get(i-1);
            for(int j=1;j<i;j++){
                int cnt1=preList.get(j);
                int cnt2=preList.get(j-1);
                curList.add(cnt1+cnt2);
            }

            curList.add(1);
            list.add(curList);
        }
        for(int i=0;i<list.size();i++){
            for(int j=0;j<list.get(i).size();j++){
                System.out.print(list.get(i).get(j)+" ");
            }
            System.out.println();
        }
    }

    public static void main3() {
        //二维数组
        List<List<Integer>> list1 = new ArrayList<>();
        List<Integer> list2=new ArrayList<>();
        List<Integer> list3=new ArrayList<>();
        list2.add(1);
        list2.add(2);
        list2.add(3);
        list3.add(4);
        list3.add(5);
        list3.add(6);
        list1.add(list2);
        list1.add(list3);
        System.out.println(list1);
    }

    public static void main2() {
        ArrayList<Integer> list = new ArrayList<>();
        //ps ArrayList的扩容默认是按照1.5倍扩容的
        //若所需扩容大大于1.5 则按用户的需求扩容
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        //使用迭代器Iterator输出
        Iterator<Integer> it=list.iterator();
        while(it.hasNext()){
            System.out.print(it.next()+" ");
        }
        System.out.println();
        //这也是迭代器 这个迭代器是Iterator的拓展 有更多的功能（前面的功能请以后再来探索吧~）
        ListIterator<Integer> It=list.listIterator();
        while(It.hasNext()){
            System.out.print(It.next()+" ");
        }
        System.out.println();
        //从后往前打印
        //这个迭代器可以从指定位置出发
        ListIterator<Integer> it2=list.listIterator(list.size());
        while(it2.hasPrevious()){//判断前面有没有元素
            System.out.print(it2.previous()+" ");
        }
        System.out.println();
    }

    public static void main1() {
        //1和2的区别是：
        //1可以通过list这个引用调用这个类所有的可以被调用的方法
        //2是个接口 只要实现这个接口的都能应用，也可以向上转型和多态
        //但2这个接口只能调用这个接口当中包含的方法 无法像1一样可以调用那么多的方法
        ArrayList<Integer> list = new ArrayList<Integer>();//1
        list.add(1);
        list.add(2);
        List<Integer> list2 = new ArrayList<Integer>();//2

        ArrayList<Integer> list3=new ArrayList<>(list);
        //这里为什么可以放list？
        //因为public ArrayList(Collection<? extends E> c)
        //这里的"?"是通配符 这一句中的<? extends E>表示这个东西要么是E要么是E的子类
        //所以list3可以接受list（因为list也是Integer）
        //简单来说就是构造方法支持 类型匹配 元素类型兼容

        System.out.println(list3);
    }
}
